{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21 - 元学习器\n",
    " \n",
    " \n",
    "回顾一下，我们现在有兴趣找到干预效果的异质性，即确定实验单元对干预的不同反应。在这个框架中，我们要估计\n",
    " \n",
    "$\n",
    "\\tau(x) = E[Y_i(1) - Y_i(0)|X] = E[\\tau_i|X]\n",
    "$\n",
    " \n",
    "或者，在连续值情况下，估计\\\\(E[\\delta Y_i(t)|X]\\\\) 。换句话说，我们想知道实验单元对处理的敏感程度。这在我们无法干预所有人并且需要对干预对象进行优先排序的情况下非常有用，例如当您想提供折扣但预算有限时。\n",
    " \n",
    "以前，我们看到了如何转换结果变量 \\\\(Y\\\\)，以便我们可以将其插入预测模型并获得条件平均干预效果 (CATE) 估计。这种情况下，我们需要付出方差增加的代价。这是我们在数据科学中看到的很多东西。没有一种最好的方法，因为每种方法都有其缺点和优点。出于这个原因，值得学习许多技术，这样您就可以根据情况在其中一种与另一种之间进行权衡。本着这种精神，本章将重点介绍更多工具供您使用。\n",
    " \n",
    "![img](data/img/meta-learners/learned-new-move.png)\n",
    " \n",
    "元学习器是一种利用现成的预测机器学习方法来解决我们迄今为止一直在研究的同一问题的简单方法：估计 CATE。同样，它们都不是最好的，每个都有其弱点。\n",
    "\n",
    "我会尝试复习它们，但请记住，这些东西高度依赖于上下文。不仅如此，元学习器还部署了预测 ML 模型，这些模型可以从线性回归和增强决策树到神经网络和高斯过程。元学习器的成功也将高度依赖于它使用什么机器学习方法作为其组件。通常你只需要尝试许多不同的东西，看看什么最有效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "from nb21 import cumulative_gain, elast"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这里，我们将使用我们之前用过的相同数据，重新再把投资广告电子邮件数据用起来。 同样，这里的目标是找出谁会更好地回复电子邮件。 不过，有一点转折。 这一次，我们将使用非随机数据来训练模型和随机数据来验证它们。 处理非随机数据是一项艰巨的任务，因为元学习器需要对数据进行纠偏**并**估计 CATE。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>income</th>\n",
       "      <th>insurance</th>\n",
       "      <th>invested</th>\n",
       "      <th>em1</th>\n",
       "      <th>em2</th>\n",
       "      <th>em3</th>\n",
       "      <th>converted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>44.1</td>\n",
       "      <td>5483.80</td>\n",
       "      <td>6155.29</td>\n",
       "      <td>14294.81</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>39.8</td>\n",
       "      <td>2737.92</td>\n",
       "      <td>50069.40</td>\n",
       "      <td>7468.15</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>49.0</td>\n",
       "      <td>2712.51</td>\n",
       "      <td>5707.08</td>\n",
       "      <td>5095.65</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>39.7</td>\n",
       "      <td>2326.37</td>\n",
       "      <td>15657.97</td>\n",
       "      <td>6345.20</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>35.3</td>\n",
       "      <td>2787.26</td>\n",
       "      <td>27074.44</td>\n",
       "      <td>14114.86</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    age   income  insurance  invested  em1  em2  em3  converted\n",
       "0  44.1  5483.80    6155.29  14294.81    0    0    1          0\n",
       "1  39.8  2737.92   50069.40   7468.15    1    0    0          0\n",
       "2  49.0  2712.51    5707.08   5095.65    0    0    1          1\n",
       "3  39.7  2326.37   15657.97   6345.20    0    0    0          0\n",
       "4  35.3  2787.26   27074.44  14114.86    1    1    0          0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = pd.read_csv(\"./data/invest_email_rnd.csv\")\n",
    "train = pd.read_csv(\"./data/invest_email_biased.csv\")\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们的结果变量是转化，我们的干预变量是 email-1。 让我们创建变量来存储这些特征以及我们用于搜索干预效果异质性的特征 \\\\(X\\\\)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"converted\"\n",
    "T = \"em1\"\n",
    "X = [\"age\", \"income\", \"insurance\", \"invested\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## S-Learner (aka, the Go-Horse Learner (to be translated))\n",
    " \n",
    "我们将使用的第一个学习器是 S-Learner。 这是我们能想到的最简单的学习器。 我们将使用单个（因此标注为S）机器学习模型 \\\\(M_s\\\\) 来估计\n",
    " \n",
    "$\n",
    "\\mu(x) = E[Y| T, X]\n",
    "$\n",
    " \n",
    "为此，我们将简单地将干预行为作为一个特征包含在模型中，以尝试预测结果 Y。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightgbm import LGBMRegressor\n",
    "\n",
    "np.random.seed(123)\n",
    "s_learner = LGBMRegressor(max_depth=3, min_child_samples=30)\n",
    "s_learner.fit(train[X+[T]], train[y]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后，我们可以在不同的干预方案下做出预测。 实验组和控制组之间的预测差异将是我们的 CATE 估计\n",
    " \n",
    "$\n",
    "\\hat{\\tau}(x)_i = M_s(X_i, T=1) - M_s(X_i, T=0)\n",
    "$\n",
    " \n",
    "如果我们把它放在图表中，这就是它的样子\n",
    " \n",
    "![img](data/img/meta-learners/s-learner.png)\n",
    " \n",
    "现在，让我们看看如何在代码中实现这个学习器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "s_learner_cate_train = (s_learner.predict(train[X].assign(**{T: 1})) -\n",
    "                        s_learner.predict(train[X].assign(**{T: 0})))\n",
    "\n",
    "s_learner_cate_test = test.assign(\n",
    "    cate=(s_learner.predict(test[X].assign(**{T: 1})) - # predict under treatment\n",
    "          s_learner.predict(test[X].assign(**{T: 0}))) # predict under control\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了评估这个模型，我们将查看测试集中的累积增益曲线。 我也会对训练集数据绘制增益曲线。 由于训练是有偏差的，这条曲线不能说明模型是否良好，但它可以指出我们是否对训练集过度拟合。 发生这种情况时，训练数据集的增益曲线将非常高。 如果您想查看它的样子，请尝试将 `max_depth` 参数从 3 替换为 20。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gain_curve_test = cumulative_gain(s_learner_cate_test, \"cate\", y=\"converted\", t=\"em1\")\n",
    "gain_curve_train = cumulative_gain(train.assign(cate=s_learner_cate_train), \"cate\", y=\"converted\", t=\"em1\")\n",
    "plt.plot(gain_curve_test, color=\"C0\", label=\"Test\")\n",
    "plt.plot(gain_curve_train, color=\"C1\", label=\"Train\")\n",
    "plt.plot([0, 100], [0, elast(test, \"converted\", \"em1\")], linestyle=\"--\", color=\"black\", label=\"Baseline\")\n",
    "plt.legend()\n",
    "plt.title(\"S-Learner\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![img](data/img/meta-learners/not-great-not-terrible.jpeg)\n",
    " \n",
    "从累积增益中我们可以看出，S-learner 虽然简单，但在这个数据集上表现还不错。 要记住的一件事是，目前这个表现是特定于这个数据集的。 根据你实际拥有的数据类型，S-learner 可能会表现得更好或更差。 在实践中，我发现对于要解决任何因果问题，S-learner 是可以作为第一个备选最优方案，主要是因为它的简单性。 不仅如此，S-learner 可以处理连续和离散干预变量，而本章中的其他学习器只能处理离散干预变量。\n",
    " \n",
    "S-learner 的主要缺点是它倾向于将干预效果估计值趋于零。 这是由于 S-learner 通常使用正则化的机器学习模型，而正则化会约束干预效果的估计值。 Chernozhukov et al (2016) 使用模拟数据概述了这个问题：\n",
    " \n",
    "![img](data/img/meta-learners/zero-bias-s-learner.png)\n",
    " \n",
    "在这里，他们使用 S-learner 绘制了真实因果效应（红色轮廓）和估计的因果效应 \\\\(\\tau - \\hat{\\tau}\\\\) 之间的差异。 因果效应的估计值严重下偏。 换句话说，真正的因果效应通常比估计的更大。\n",
    " \n",
    "更糟糕的是，如果干预变量相对于其他协变量在解释结果方面的影响非常弱，S-learner 可以完全丢弃干预变量。 请注意，这与您使用的所选 ML 模型高度相关。 正则化越强，问题就越大。 解决这个问题的一个尝试是我们将看到的下一个学习器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## T-Learner (T-学习器)\n",
    " \n",
    "为了解决干预变量在模型拟合过程中被丢弃的现象，T-learner 试图强制让学习器首先通过干预变量分类对样本进行拆分。我们将不使用单个模型，而是每个处理变量的分类数值使用一个模型。在二分类情况下，我们只需要估计两个模型（因此得名 T）：\n",
    " \n",
    "$\n",
    "\\mu_0(x) = E[Y| T=0, X]\n",
    "$\n",
    " \n",
    "$\n",
    "\\mu_1(x) = E[Y| T=1，X]\n",
    "$\n",
    " \n",
    "然后，在预测时，我们可以对每种处理进行反事实预测，并得到如下 CATE。\n",
    " \n",
    "$\n",
    "\\hat{\\tau}(x)_i = M_1(X_i) - M_0(X_i)\n",
    "$\n",
    " \n",
    "这是这个学习器的示意图\n",
    " \n",
    "![img](data/img/meta-learners/t-learner.png)\n",
    " \n",
    "我们可以做的另一个简单改进是使用倾向得分加权来消除我们的模型的偏差。这将产生一个与双重鲁棒估计器非常相似的模型，但其中使用的回归模型被更通用的机器学习模型所取代。\n",
    " \n",
    "$\n",
    "\\hat{ATE} = \\frac{1}{N}\\sum \\bigg( \\dfrac{T_i(Y_i - \\hat{M_1}(X_i))}{\\hat{P}(X_i)} + \\hat{ M_1}(X_i) \\bigg) - \\frac{1}{N}\\sum \\bigg( \\dfrac{(1-T_i)(Y_i - \\hat{M_0}(X_i))}{1-\\hat{P }(X_i)} + \\hat{M_0}(X_i) \\bigg)\n",
    "$\n",
    " \n",
    "顺便说一句，你也可以用 S-learner 做同样的事情，我只是之前没有这样做，因为我不想一次扔给你太多的新概念。现在，关于理论足够了。让我们试试代码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "np.random.seed(123)\n",
    "\n",
    "m0 = LGBMRegressor(max_depth=2, min_child_samples=60)\n",
    "m1 = LGBMRegressor(max_depth=2, min_child_samples=60)\n",
    "\n",
    "# fit the propensity score model\n",
    "ps_m = LogisticRegression(solver=\"lbfgs\", penalty='none')\n",
    "ps_m.fit(train[X], train[T])\n",
    "ps_score = ps_m.predict_proba(train[X])\n",
    "\n",
    "m0.fit(train.query(f\"{T}==0\")[X], train.query(f\"{T}==0\")[y],\n",
    "       sample_weight=1/ps_m.predict_proba(train.query(f\"{T}==0\")[X])[:, 0])\n",
    "\n",
    "m1.fit(train.query(f\"{T}==1\")[X], train.query(f\"{T}==1\")[y],\n",
    "       sample_weight=1/ps_m.predict_proba(train.query(f\"{T}==1\")[X])[:, 1])\n",
    "\n",
    "# estimate the CATE\n",
    "t_learner_cate_train = m1.predict(train[X]) - m0.predict(train[X])\n",
    "t_learner_cate_test = test.assign(cate=m1.predict(test[X]) - m0.predict(test[X]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gain_curve_test = cumulative_gain(t_learner_cate_test, \"cate\", y=\"converted\", t=\"em1\")\n",
    "gain_curve_train = cumulative_gain(train.assign(cate=t_learner_cate_train), \"cate\", y=\"converted\", t=\"em1\")\n",
    "plt.plot(gain_curve_test, color=\"C0\", label=\"Test\")\n",
    "plt.plot(gain_curve_train, color=\"C1\", label=\"Train\")\n",
    "plt.plot([0, 100], [0, elast(test, \"converted\", \"em1\")], linestyle=\"--\", color=\"black\", label=\"Baseline\")\n",
    "plt.legend();\n",
    "plt.title(\"T-Learner\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "T-learner 在这个数据集上也表现良好。测试性能看起来与我们使用 S-learner 得到的结果并没有太大区别。也许是因为干预的效果不是那么弱。此外，我们可以看到训练集上的表现远高于测试集上的表现。这表明模型过度拟合。之所以会发生这种情况，是因为我们仅将每个模型拟合到数据的子集上。由于数据点较少，模型可能正在学习一些噪音。\n",
    " \n",
    "T-Learner 避免了没法将干预效果较弱的干预变量不剔除于模型的问题，但它仍然会受到正则化偏差的影响。考虑以下取自 Kunzela 等人2019年论文描述的情况。这里，未经干预的样本数据很多，而受到干预的样本数据很少，这是许多实际应用中常见的情况，因为进行干预通常成本很高。现在假设您在结果 Y 中存在**干预效果恒定**，但有着非线性的关系。我们可以在下图中看到发生了什么\n",
    " \n",
    "![img](data/img/meta-learners/t-learner-problem.png)\n",
    " \n",
    "在这里，由于我们干预后的观察结果很少，\\\\(M_1\\\\) 将是一个非常简单的模型（在这种情况下是线性的）以避免过度拟合。 \\\\(M_0\\\\) 会更复杂，但这没关系，因为大量的数据可以防止过度拟合。从机器学习的角度来看，这一切都是合理的。但是，如果我们使用这些模型来计算类别 \\\\(\\hat{\\tau}=M_1(X) - M_0(X)\\\\)，则 \\\\(M_0(X)\\\\) 的非线性减去\\\\(M_1(X)\\\\) 的线性将导致非线性 CATE（蓝线减去红线），这是错误的，因为在这种情况下 CATE 是恒定的并且等于 1。\n",
    " \n",
    "这里发生的是，未干预样本对应的模型可以拾取非线性，但干预样本的模型不能，因为我们使用正则化来处理小样本量。当然，您可以在该模型上使用较少的正则化，但是小样本量会导致您过拟合。好像我们被夹在一块石头和一个坚硬的地方之间。为了解决这个问题，我们可以使用 Kunzela 等人在同一篇论文中提出的 X-learner。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## X-Learner（X-学习器）\n",
    " \n",
    "X-learner 的解释比之前的学习器要复杂得多，但它的实现非常简单，所以不用担心。 X-Learner 有两个阶段和一个倾向评分模型。第一个与 T-learner 相同。首先，我们将样本分成干预过的和未经干预的，并为干预过样本的和未干预样本分别拟合一个 ML 模型。\n",
    " \n",
    "$\n",
    "\\hat{M}_0(X) \\approx E[Y| T=0, X]\n",
    "$\n",
    " \n",
    "$\n",
    "\\hat{M}_1(X) \\approx E[Y| T=1，X]\n",
    "$\n",
    " \n",
    "现在，事情开始出现转机。对于第二阶段，我们使用上述模型输入干预样本和未干预样本的干预效果。\n",
    " \n",
    "$\n",
    "\\hat{\\tau}(X, T=0) = \\hat{M}_1(X, T=0) - Y_{T=0}\n",
    "$\n",
    " \n",
    "$\n",
    "\\hat{\\tau}(X, T=1) = Y_{T=1} - \\hat{M}_0(X, T=1)\n",
    "$\n",
    " \n",
    "然后，我们再拟合两个模型来预测这些影响\n",
    " \n",
    "$\n",
    "\\hat{M}_{\\tau 0}(X) \\approx E[\\hat{\\tau}(X)|T=0]\n",
    "$\n",
    " \n",
    "$\n",
    "\\hat{M}_{\\tau 1}(X) \\approx E[\\hat{\\tau}(X)|T=1]\n",
    "$\n",
    " \n",
    "如果我们将这个应用到我们之前展示过的图像上，\\\\(\\hat{\\tau}(X, T=0)\\\\)，对未干预样本的估算干预效果，将是红色+号对应的线，而红色虚线对应的是是 \\\\(\\hat{M}_{\\tau 0}(X)\\\\)。注意这个模型是错误的。因为 \\\\(\\hat{\\tau}(X, T=0)\\\\) 是使用正则化的简单模型得到的，对干预后样本的 \\\\(\\hat{M}_1\\\\) 估计。它输入的治疗效果是非线性的，因为它**没有**捕获 Y 变量中的非线性关系。\n",
    " \n",
    "相反，蓝点是干预样本的估算干预效果，\\\\(\\hat{\\tau}(X, T=1)\\\\)。这些影响是使用正确的模型，\\\\(M_0\\\\)，在未经干预的大量样本中进行训练得到的结果。因此，由于其估算的干预效果是正确的，我们能够训练出正确的第二阶段模型 \\\\(\\hat{M}_{\\tau 1}(X)\\\\)，如蓝线所示。\n",
    " \n",
    "![img](data/img/meta-learners/second-stage-x.png)\n",
    " \n",
    "所以我们有一个模型是错误的，因为我们错误地输入了干预效果，而另一个模型是正确的，因为我们正确地估算了这些值。现在，我们需要一种将两者结合起来的方法，以赋予正确模型更多的权重。这就是倾向得分模型发挥作用的地方。设 \\\\(\\hat{e}(x)\\\\) 为倾向得分模型，我们可以将两个第二阶段模型组合如下：\n",
    " \n",
    "$\n",
    "\\hat{\\tau(x)} = \\hat{M}_{\\tau 0}(X)(\\hat{e}(x)) + \\hat{M}_{\\tau 1}(X)( 1-\\hat{e}(x))\n",
    "$\n",
    " \n",
    "由于干预过的样本很少，\\\\(\\hat{e}(x)\\\\) 非常小。这会给错误的模型 \\\\(\\hat{M}_{\\tau 0}(X)\\\\) 赋予很小的权重。\n",
    "\n",
    "相比之下，\\\\(1-\\hat{e}(x)\\\\) 接近于1，所以我们会给正确的模型很高的权重 \\\\(\\hat{M}_{\\tau 1}( X）\\\\）。更一般地说，使用倾向得分的加权平均将确保我们对 CATE 模型给予更多的权重，该模型的估计使用更有可能进行干预的样本。换句话说，我们将倾向于使用更多数据训练的模型。下图显示了 X-learner 和 T-learner 给出的估计 CATE。\n",
    " \n",
    "![img](data/img/meta-learners/t-vs-x-learner.png)\n",
    " \n",
    "正如我们所看到的，与 T-learner 相比，X-learner 在纠正非线性估计的错误 CATE 方面做得更好。一般来说，当一个干预组比另一个大得多时，X-learner 的表现会更好。\n",
    " \n",
    "我知道这可能有点拗口，但是一旦我们开始实施，希望它会很清楚。总结一下，这里是这个学习器的示意图。\n",
    " \n",
    "![img](data/img/meta-learners/x-learner.png)\n",
    " \n",
    "先来看看代码！首先，我们有个第一阶段模型，它与 T-Learner 完全相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "np.random.seed(123)\n",
    "\n",
    "# first stage models\n",
    "m0 = LGBMRegressor(max_depth=2, min_child_samples=30)\n",
    "m1 = LGBMRegressor(max_depth=2, min_child_samples=30)\n",
    "\n",
    "# propensity score model\n",
    "g = LogisticRegression(solver=\"lbfgs\", penalty='none') \n",
    "\n",
    "m0.fit(train.query(f\"{T}==0\")[X], train.query(f\"{T}==0\")[y])\n",
    "m1.fit(train.query(f\"{T}==1\")[X], train.query(f\"{T}==1\")[y])\n",
    "                       \n",
    "g.fit(train[X], train[T]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们估算干预效果，并将其用于第二阶段模型的拟合。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_train = np.where(train[T]==0,\n",
    "                   m1.predict(train[X]) - train[y],\n",
    "                   train[y] - m0.predict(train[X]))\n",
    "\n",
    "# second stage\n",
    "mx0 = LGBMRegressor(max_depth=2, min_child_samples=30)\n",
    "mx1 = LGBMRegressor(max_depth=2, min_child_samples=30)\n",
    "\n",
    "mx0.fit(train.query(f\"{T}==0\")[X], d_train[train[T]==0])\n",
    "mx1.fit(train.query(f\"{T}==1\")[X], d_train[train[T]==1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，我们使用倾向性得分模型得到正确的预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ps_predict(df, t): \n",
    "    return g.predict_proba(df[X])[:, t]\n",
    "    \n",
    "    \n",
    "x_cate_train = (ps_predict(train,0)*mx0.predict(train[X]) +\n",
    "                ps_predict(train,1)*mx1.predict(train[X]))\n",
    "\n",
    "x_cate_test = test.assign(cate=(ps_predict(test,0)*mx0.predict(test[X]) +\n",
    "                                ps_predict(test,1)*mx1.predict(test[X])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "让我们看看我们的X-learner在测试集上的表现。我们任然需要绘制累计增益曲线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gain_curve_test = cumulative_gain(x_cate_test, \"cate\", y=\"converted\", t=\"em1\")\n",
    "gain_curve_train = cumulative_gain(train.assign(cate=x_cate_train), \"cate\", y=\"converted\", t=\"em1\")\n",
    "plt.plot(gain_curve_test, color=\"C0\", label=\"Test\")\n",
    "plt.plot(gain_curve_train, color=\"C1\", label=\"Train\")\n",
    "plt.plot([0, 100], [0, elast(test, \"converted\", \"em1\")], linestyle=\"--\", color=\"black\", label=\"Baseline\")\n",
    "plt.legend();\n",
    "plt.title(\"X-Learner\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这个数据集上的表现仍然不错。在这里，S、T 和 X 学习器的表现似乎非常相似。尽管如此，我认为值得了解所有这些元学习器，这样你就可以使用最适合你的东西。请记住，性能也高度依赖于我们选择的基础机器学习模型。在这里，我们使用 Gradient Boosted Trees 完成了所有工作，但也许其他模型甚至是使用不同超参数的Gradient Boosted Trees模型可能会更好。\n",
    " \n",
    "## 关键思想\n",
    " \n",
    "同样，我们可以做的最简单的事情是使用单个或 S-learner 并将干预作为特征。当干预不是结果的弱预测因素时，这往往会很好地发挥作用。但如果不是这样，S-learner 往往会得到偏向于零的干预效果估计量，甚至完全放弃干预变量作为影响因子。稍微复杂一点的情形下，我们可以通过使用 T-learner 来强制让学习器估计干预的影响。在这里，我们为每个干预水平拟合一个机器学习模型。当所有干预水平都有足够的样本时，这很有效，但当一个干预水平的样本量较小时，它可能会失败，从而迫使模型被高度正则化。为了解决这个问题，我们可以使用 X-learner 增加另一个级别的复杂性，其中我们有两个拟合阶段，并且我们使用倾向得分模型来纠正由于模型使用了很少数据点来进行估计造成潜在错误。\n",
    " \n",
    "这些学习器（S-learner 除外）的一个大问题是他们采用二元或分类处理。还有一个我们还没有看到的额外学习器，它更通用：R-learner。但别担心，我们将有一整章专门介绍它。\n",
    " "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
